1 Image Processing and Enhancement

1.1 Blurring an Image

import cv2
from  matplotlib import pyplot as plt


image_path = 'content/cats-dogs.png'
image = cv2.imread(image_path)
resized_image = cv2.resize(image, (2000, 1000))
resized_image_rgb = cv2.cvtColor(resized_image, cv2.COLOR_BGR2RGB)
plt.imshow(resized_image_rgb)
plt.title('Original Image')
plt.axis('off')
plt.show()

1.1.1 Gaussian Blurring

Gaussian = cv2.GaussianBlur(resized_image, (15, 15), 0)  
Gaussian_rgb = cv2.cvtColor(Gaussian, cv2.COLOR_BGR2RGB)  
plt.imshow(Gaussian_rgb)
plt.title('Gaussian Blurred Image')
plt.axis('off')
plt.show()

1.1.2 Median Blur

median = cv2.medianBlur(resized_image, 11)  
median_rgb = cv2.cvtColor(median, cv2.COLOR_BGR2RGB)  

plt.imshow(median_rgb)
plt.title('Median Blurred Image')
plt.axis('off')
plt.show()

1.1.3 Bilateral Blur

bilateral = cv2.bilateralFilter(resized_image, 15, 150, 150)  
bilateral_rgb = cv2.cvtColor(bilateral, cv2.COLOR_BGR2RGB)  

plt.imshow(bilateral_rgb)
plt.title('Bilateral Blurred Image')
plt.axis('off')
plt.show()

1.2 Grayscaling of Images

1.2.1 Method 1: Using the cvcvtColor() function

import cv2
tomatoes = 'content/tomatoes.png'
image = cv2.imread(tomatoes)

gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

cv2.imshow('Grayscale', gray_image)
cv2.waitKey(0)  
cv2.destroyAllWindows()

import matplotlib.pyplot as plt

plt.figure(figsize=(16, 6))


plt.subplot(1, 2, 1)
img = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
plt.imshow(img)
plt.title("Original Image")
plt.axis('off')

plt.subplot(1, 2, 2)
plt.imshow(gray_image, cmap='gray')
plt.title("Grayscale Image")
plt.axis('off')

plt.show()

1.2.2 Method 2: Using the cvimread() function with flag=zero

import cv2

img = cv2.imread(tomatoes, 0)

cv2.imshow('Grayscale Image', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

im = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
plt.imshow(im)

<matplotlib.image.AxesImage at 0x1b395366180>

1.2.3 Method 1 Weighted Method (Recommended)

import cv2

img_weighted = cv2.imread(tomatoes)
rows, cols = img_weighted.shape[:2]

for i in range(rows):
    for j in range(cols):
        gray = 0.2989 * img_weighted[i, j][2] + 0.5870 * img_weighted[i, j][1] + 0.1140 * img_weighted[i, j][0]
        img_weighted[i, j] = [gray, gray, gray]

cv2.imshow('Grayscale Image (Weighted)', img_weighted)
cv2.waitKey(0)
cv2.destroyAllWindows()

imo = cv2.cvtColor(img_weighted, cv2.COLOR_BGR2RGB)
plt.imshow(imo)

<matplotlib.image.AxesImage at 0x1b395366b10>

1.2.4 Method 2: Using the pixel manipulation (Average method)

import cv2

img = cv2.imread(tomatoes)
rows, cols = img.shape[:2]

for i in range(rows):
    for j in range(cols):
        # Convert to float() so the sum can exceed 255
        r = float(img[i, j, 0])
        g = float(img[i, j, 1])
        b = float(img[i, j, 2])
        
        gray = int((r + g + b) / 3)
    
        img[i, j] = [gray, gray, gray]
cv2.imshow('Grayscale Image (Average)', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

im = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
plt.imshow(im)

<matplotlib.image.AxesImage at 0x1b39a019370>

1.3 Scaling, Rotating, Shifting and Edge Detection

1.3.1 Image Resizing

import cv2
import numpy as np
import matplotlib.pyplot as plt

morti = 'content/Ganeshji-org.webp'

image = cv2.imread(morti)
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
scale_factor_1 = 3.0  
scale_factor_2 = 1/3.0
height, width = image_rgb.shape[:2]
new_height = int(height * scale_factor_1)
new_width = int(width * scale_factor_1)

zoomed_image = cv2.resize(src =image_rgb, 
                          dsize=(new_width, new_height), 
                          interpolation=cv2.INTER_CUBIC)
                          
new_height1 = int(height * scale_factor_2)
new_width1 = int(width * scale_factor_2)
scaled_image = cv2.resize(src= image_rgb, 
                          dsize =(new_width1, new_height1), 
                          interpolation=cv2.INTER_AREA)

fig, axs = plt.subplots(1, 3, figsize=(10, 4))
axs[0].imshow(image_rgb)
axs[0].set_title('Original Image Shape:'+str(image_rgb.shape))
axs[1].imshow(zoomed_image)
axs[1].set_title('Zoomed Image Shape:'+str(zoomed_image.shape))
axs[2].imshow(scaled_image)
axs[2].set_title('Scaled Image Shape:'+str(scaled_image.shape))

for ax in axs:
    ax.set_xticks([])
    ax.set_yticks([])

plt.tight_layout()
plt.show()

1.3.2 Image Rotation

import cv2
import matplotlib.pyplot as plt
img = cv2.imread(morti)
image_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
center = (image_rgb.shape[1] // 2, image_rgb.shape[0] // 2)
angle = 30
scale = 1
rotation_matrix = cv2.getRotationMatrix2D(center, angle, scale)
rotated_image = cv2.warpAffine(image_rgb, rotation_matrix, (img.shape[1], img.shape[0]))

fig, axs = plt.subplots(1, 2, figsize=(7, 4))
axs[0].imshow(image_rgb)
axs[0].set_title('Original Image')
axs[1].imshow(rotated_image)
axs[1].set_title('Image Rotation')
for ax in axs:
    ax.set_xticks([])
    ax.set_yticks([])
    
plt.tight_layout()
plt.show()

1.3.3 Image Translation

import cv2
import matplotlib.pyplot as plt
import numpy as np

img = cv2.imread(morti)
image_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
width, height = image_rgb.shape[1], image_rgb.shape[0]

tx, ty = 100, 70
translation_matrix = np.array([[1, 0, tx], [0, 1, ty]], dtype=np.float32)
translated_image = cv2.warpAffine(image_rgb, translation_matrix, (width, height))

fig, axs = plt.subplots(1, 2, figsize=(7, 4))
axs[0].imshow(image_rgb), axs[0].set_title('Original Image')
axs[1].imshow(translated_image), axs[1].set_title('Image Translation')

for ax in axs:
    ax.set_xticks([]), ax.set_yticks([])

plt.tight_layout()
plt.show()

1.3.4 Image Shearing

import cv2
import numpy as np
import matplotlib.pyplot as plt

image = cv2.imread(morti)
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
width, height = image_rgb.shape[1], image_rgb.shape[0]

shearX, shearY = -0.15, 0
transformation_matrix = np.array([[1, shearX, 0], [0, 1, shearY]], dtype=np.float32)
sheared_image = cv2.warpAffine(image_rgb, transformation_matrix, (width, height))

fig, axs = plt.subplots(1, 2, figsize=(7, 4))
axs[0].imshow(image_rgb), axs[0].set_title('Original Image')
axs[1].imshow(sheared_image), axs[1].set_title('Sheared Image')

for ax in axs:
    ax.set_xticks([]), ax.set_yticks([])

plt.tight_layout()
plt.show()

1.3.5 Image Normalization

import cv2
import numpy as np
import matplotlib.pyplot as plt

image = cv2.imread(morti)
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
b, g, r = cv2.split(image_rgb)

b_normalized = cv2.normalize(b.astype('float'), None, 0, 1, cv2.NORM_MINMAX)
g_normalized = cv2.normalize(g.astype('float'), None, 0, 1, cv2.NORM_MINMAX)
r_normalized = cv2.normalize(r.astype('float'), None, 0, 1, cv2.NORM_MINMAX)

normalized_image = cv2.merge((b_normalized, g_normalized, r_normalized))
print(normalized_image[:, :, 0])

plt.imshow(normalized_image)
plt.xticks([]), 
plt.yticks([]), 
plt.title('Normalized Image')
plt.show()

[[0.08627451 0.08627451 0.08627451 ... 0.08627451 0.10588235 0.16078431]
 [0.08627451 0.08627451 0.08627451 ... 0.05882353 0.08235294 0.1372549 ]
 [0.08627451 0.08627451 0.08627451 ... 0.0745098  0.09411765 0.14901961]
 ...
 [0.08235294 0.02745098 0.00784314 ... 0.08235294 0.09019608 0.11764706]
 [0.10588235 0.05098039 0.03137255 ... 0.09019608 0.09803922 0.1254902 ]
 [0.11764706 0.0627451  0.04705882 ... 0.09803922 0.10980392 0.1372549 ]]

1.3.6 Edge detection of Image

import cv2
import numpy as np
import matplotlib.pyplot as plt

img = cv2.imread(morti)
image_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
edges = cv2.Canny(image_rgb, 100, 700)

fig, axs = plt.subplots(1, 2, figsize=(7, 4))
axs[0].imshow(image_rgb), axs[0].set_title('Original Image')
axs[1].imshow(edges), axs[1].set_title('Image Edges')

for ax in axs:
    ax.set_xticks([]), ax.set_yticks([])

plt.tight_layout()
plt.show()

1.3.7 Image Blurring

import cv2
import numpy as np
import matplotlib.pyplot as plt

image = cv2.imread(morti)
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
blurred = cv2.GaussianBlur(image, (3, 3), 0)
blurred_rgb = cv2.cvtColor(blurred, cv2.COLOR_BGR2RGB)

fig, axs = plt.subplots(1, 2, figsize=(7, 4))
axs[0].imshow(image_rgb), axs[0].set_title('Original Image')
axs[1].imshow(blurred_rgb), axs[1].set_title('Blurred Image')

for ax in axs:
    ax.set_xticks([]), ax.set_yticks([])

plt.tight_layout()
plt.show()

1.3.8 Morphological Image Processing

import cv2
import numpy as np
import matplotlib.pyplot as plt

image = cv2.imread(morti)
image_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
kernel = np.ones((3, 3), np.uint8)

dilated = cv2.dilate(image_gray, kernel, iterations=2)
eroded = cv2.erode(image_gray, kernel, iterations=2)
opening = cv2.morphologyEx(image_gray, cv2.MORPH_OPEN, kernel)
closing = cv2.morphologyEx(image_gray, cv2.MORPH_CLOSE, kernel)

fig, axs = plt.subplots(2, 2, figsize=(7, 7))
axs[0, 0].imshow(dilated, cmap='Greys'), axs[0, 0].set_title('Dilated Image')
axs[0, 1].imshow(eroded, cmap='Greys'), axs[0, 1].set_title('Eroded Image')
axs[1, 0].imshow(opening, cmap='Greys'), axs[1, 0].set_title('Opening')
axs[1, 1].imshow(closing, cmap='Greys'), axs[1, 1].set_title('Closing')

for ax in axs.flatten():
    ax.set_xticks([]), ax.set_yticks([])

plt.tight_layout()
plt.show()

1.4 Intensity Transformation Operations on Images

1.4.1 Log Transformations

import cv2
import numpy as np

camer = 'content/sample.jpg'

# Open the image.
img = cv2.imread(camer)

# Apply log transform.
c = 255/(np.log(1 + np.max(img)))
log_transformed = c * np.log(1 + img)

# Specify the data type.
log_transformed = np.array(log_transformed, dtype = np.uint8)

# Save the output.
# cv2.imwrite('log_transformed.jpg', log_transformed)

plt.imshow(log_transformed)

<matplotlib.image.AxesImage at 0x1b3818841d0>

1.4.2 Power-Law (Gamma) Transformation

import cv2
import numpy as np
import matplotlib.pyplot as plt

img = cv2.imread(camer)

img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

gammas = [0.1, 0.5, 1.2, 2.2]
plt.figure(figsize=(10, 8))

for i, gamma in enumerate(gammas):
    # Apply gamma correction
    gamma_corrected = np.array(255 * (img_rgb / 255) ** gamma, dtype='uint8')
    
    # Create a subplot in a 2x2 grid
    plt.subplot(2, 2, i + 1)
    plt.imshow(gamma_corrected)
    plt.title(f'Gamma: {gamma}')
    plt.axis('off') # Hide x/y axes for a cleaner look

plt.tight_layout()
plt.show()

1.4.3 Piecewise-Linear Transformation Functions

import cv2
import numpy as np

# Function to map each intensity level to output intensity level.
def pixelVal(pix, r1, s1, r2, s2):
    if (0 <= pix and pix <= r1):
        return (s1 / r1)*pix
    elif (r1 < pix and pix <= r2):
        return ((s2 - s1)/(r2 - r1)) * (pix - r1) + s1
    else:
        return ((255 - s2)/(255 - r2)) * (pix - r2) + s2

# Open the image.
img = cv2.imread(camer)

# Define parameters.
r1 = 70
s1 = 0
r2 = 140
s2 = 255

# Vectorize the function to apply it to each value in the Numpy array.
pixelVal_vec = np.vectorize(pixelVal)

# Apply contrast stretching.
contrast_stretched = pixelVal_vec(img, r1, s1, r2, s2)

# Save edited image.
# cv2.imwrite('contrast_stretch.jpg', contrast_stretched)

plt.imshow(contrast_stretched)
plt.title('Contrast Stretched Image')
plt.axis('off') 

Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.0..255.0].

(np.float64(-0.5), np.float64(1299.5), np.float64(866.5), np.float64(-0.5))

1.5 Image Translation

1.5.1 Example 1: Translating the Image Right and Down

import cv2
import numpy as np
# from google.colab.patches import cv2_imshow

image = cv2.imread(tomatoes)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

height, width = image.shape[:2]
quarter_height, quarter_width = height / 4, width / 4

T = np.float32([[1, 0, quarter_width], [0, 1, quarter_height]])

img_translation = cv2.warpAffine(image, T, (width, height))


plt.imshow(image)
plt.title('Original Image')
plt.axis('off')
plt.show()

plt.imshow(img_translation)
plt.title('Translated Image')
plt.axis('off') 
plt.show()

print("hello world")

hello world

1.5.2 Example 2: Performing Multiple Translations

import cv2
import numpy as np
import matplotlib.pyplot as plt

img = cv2.imread(tomatoes)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

rows, cols, _ = img.shape

M_left = np.float32([[1, 0, -50], [0, 1, 0]])
M_right = np.float32([[1, 0, 50], [0, 1, 0]])
M_top = np.float32([[1, 0, 0], [0, 1, 50]])
M_bottom = np.float32([[1, 0, 0], [0, 1, -50]])

img_left = cv2.warpAffine(img, M_left, (cols, rows))
img_right = cv2.warpAffine(img, M_right, (cols, rows))
img_top = cv2.warpAffine(img, M_top, (cols, rows))
img_bottom = cv2.warpAffine(img, M_bottom, (cols, rows))

plt.subplot(221), plt.imshow(img_left), plt.title('Left')
plt.subplot(222), plt.imshow(img_right), plt.title('Right')
plt.subplot(223), plt.imshow(img_top), plt.title('Top')
plt.subplot(224), plt.imshow(img_bottom), plt.title('Bottom')
plt.show()

1.6 Image Pyramid

1.6.1 Pyramid Down with cvpyrDown()

import cv2
import numpy as np
# from google.colab.patches import cv2_imshow

image = cv2.imread(tomatoes)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

downsampled_image = cv2.pyrDown(image)

fig, axes = plt.subplots(1, 2, figsize=(12, 6))
axes[0].imshow(image)
axes[0].set_title('Original Image')
axes[0].axis('off')

axes[1].imshow(downsampled_image)
axes[1].set_title('Downsampled Image')
axes[1].axis('off')

plt.tight_layout()
plt.show()

1.6.2 Pyramid Up with cvpyrUp()

import cv2
import numpy as np


image = cv2.imread(tomatoes)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

upsampled_image = cv2.pyrUp(image)

plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.imshow(image)
plt.title('Original Image')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.imshow(upsampled_image)
plt.title('Upsampled Image')
plt.axis('off')

plt.tight_layout()
plt.show()

1.6.3 Building a Gaussian Pyramid (Multiple Levels)

import cv2

image = cv2.imread(camer)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

pyramid = [image]

for i in range(3): 
    image = cv2.pyrDown(image)
    pyramid.append(image)

for i in range(len(pyramid)-1, -1, -1):  
    print(f"Camera Level {i}")
    plt.imshow(pyramid[i])
    plt.title(f'Pyramid Level {i}')
    plt.axis('off')
    plt.show()
    
cv2.destroyAllWindows()

Camera Level 3

Camera Level 2

Camera Level 1

Camera Level 0

1.7 Histograms Equalization

1.7.1 Step Importing Libraries

import cv2
import numpy as np
import matplotlib.pyplot as plt

1.7.2 Step Applying Histogram Equalization

img = cv2.imread(tomatoes, 0)  
equ = cv2.equalizeHist(img)
res = np.hstack((img, equ))

1.7.3 Step Displaying the Result

plt.figure(figsize=(12, 6))
res = cv2.cvtColor(res, cv2.COLOR_BGR2RGB)
plt.imshow(res)  
plt.title("Original vs Equalized Image")
plt.axis('off')  
plt.show()

1.8 Convert an image from one color space to another

1.8.1 Example 1: Convert BGR to Grayscale

import cv2
src = cv2.imread(tomatoes)  # Read the image
src = cv2.cvtColor(src, cv2.COLOR_BGR2RGB)  # Convert to RGB for displaying with Matplotlib

# Convert to Grayscale
gray_image = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY)
gray_image = cv2.cvtColor(gray_image, cv2.COLOR_GRAY2RGB) 


plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.imshow(src)
plt.title("Original Image")
plt.axis('off') 

plt.subplot(1, 2, 2)
plt.imshow(gray_image)
plt.title("Grayscale Image")
plt.axis('off')

(np.float64(-0.5), np.float64(296.5), np.float64(199.5), np.float64(-0.5))

1.8.2 Example 2: Convert BGR to HSV

import cv2
src = cv2.imread(tomatoes)  # Read the image

# Convert to HSV
hsv_image = cv2.cvtColor(src, cv2.COLOR_BGR2HSV)

cv2.imshow("HSV Image", hsv_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

imag = cv2.imread('content/hsv-tomato.png')
imag = cv2.cvtColor(imag, cv2.COLOR_BGR2RGB)

plt.imshow(imag)

<matplotlib.image.AxesImage at 0x1b3801e8290>

1.8.3 Example 3: Convert BGR to RGB (For Matplotlib)

import cv2
import matplotlib.pyplot as plt
src = cv2.imread(tomatoes)

# Convert from BGR to RGB
rgb_image = cv2.cvtColor(src, cv2.COLOR_BGR2RGB)

# Display with Matplotlib
plt.imshow(rgb_image)
plt.title("RGB Image for Matplotlib")
plt.axis('off')
plt.show()

1.9 Visualizing image in different color spaces

1.9.1 RGB Image

# Python program to read image as RGB

# Importing cv2 and matplotlib module
import cv2
import matplotlib.pyplot as plt

# reads image as RGB
img = cv2.imread(tomatoes)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

# shows the image
plt.imshow(img)

<matplotlib.image.AxesImage at 0x1b3856add30>

1.9.2 Gray Scale Image

def rgb_for_metplot(img, mod, title):
    image = cv2.cvtColor(img, mod)
    plt.figure()
    plt.imshow(image)
    plt.title(title)
    plt.axis('off')
    plt.show() 

# Python program to read image as GrayScale

# Importing cv2 module
import cv2

# Reads image as gray scale
img = cv2.imread(tomatoes) 

# We can alternatively convert
# image by using cv2color
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)

# Shows the image
# cv2.imshow('image', img) 
# cv2.waitKey(0)         
# cv2.destroyAllWindows()

rgb_for_metplot(img,cv2.COLOR_GRAY2RGB , "Grayscale Image")

rgb_for_metplot(img,cv2.COLOR_GRAY2RGB, "Random stuf")

1.9.3 YCrCb Color Space

# Python program to read image
# as YCrCb color space

# Import cv2 module
import cv2

# Reads the image
img = cv2.imread(tomatoes)

# Convert to YCrCb color space
img = cv2.cvtColor(img, cv2.COLOR_BGR2YCrCb)

# Shows the image
cv2.imshow('image', img) 

cv2.waitKey(0)         
cv2.destroyAllWindows()

# rgb_for_metplot(img, cv2.COLOR_YCrCb2RGB)
plt.imshow(img)

<matplotlib.image.AxesImage at 0x1b3818ab260>

1.9.4 HSV color space

# Python program to read image
# as HSV color space

# Importing cv2 module
import cv2

# Reads the image
img = cv2.imread(tomatoes)

# Converts to HSV color space
img = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)

# Shows the image
cv2.imshow('image', img) 

cv2.waitKey(0)         
cv2.destroyAllWindows()

1.9.5 LAB color space

# Python program to read image
# as LAB color space

# Importing cv2 module
import cv2

# Reads the image
img = cv2.imread(tomatoes)

# Converts to LAB color space
img = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)

# Shows the image
cv2.imshow('image', img) 

cv2.waitKey(0)         
cv2.destroyAllWindows()

1.9.6 Edge map of image

# Python program to read image
# as EdgeMap

# Importing cv2 module
import cv2

# Reads the image
img = cv2.imread(tomatoes)


laplacian = cv2.Laplacian(img, cv2.CV_64F)
cv2.imshow('EdgeMap', laplacian) 

cv2.waitKey(0)         
cv2.destroyAllWindows()

1.9.7 Heat map of image

import cv2
import matplotlib.pyplot as plt

# 1. Image load karein
img = cv2.imread(tomatoes)

# 2. Image ko Grayscale mein convert karein (Zaroori Step)
gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# 3. Ab 'hot' colormap apply karein
plt.figure(figsize=(8, 6))
plt.imshow(gray_img, cmap='hot') 

# Colorbar dikhane ke liye takay intensity samajh aaye
plt.colorbar() 
plt.title('Heatmap (Hot Colormap)')
plt.axis('off')
plt.show()

1.9.8 Spectral Image map

import cv2
import matplotlib.pyplot as plt

# 1. Image load karein
img = cv2.imread(tomatoes)

# 2. Image ko Grayscale (Single Channel) mein convert karein
# Spectral map tabhi apply hoga jab image 2D array hogi
gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# 3. Ab 'nipy_spectral' colormap apply karein
plt.figure(figsize=(10, 7))
plt.imshow(gray_img, cmap='nipy_spectral')

# Colorbar lazmi lagayein takay pata chale kaunsi intensity kis color ki hai
plt.colorbar()
plt.title('Spectral Map Visualization')
plt.axis('off')
plt.show()

1.10 Create Border around Images

import cv2

image = cv2.imread(tomatoes)
image = cv2.copyMakeBorder( image, 10, 10, 10, 10, cv2.BORDER_CONSTANT, value=(0, 0, 0))

cv2.imshow("Bordered Image", image)
cv2.waitKey(0)
cv2.destroyAllWindows()

rgb_for_metplot(image, cv2.COLOR_BGR2RGB, "Random stuf")

1.10.1 Examples 1

import cv2

image = cv2.imread(tomatoes)

border_reflect = cv2.copyMakeBorder(image, 50, 50, 50, 50, cv2.BORDER_REFLECT)
border_reflect_101 = cv2.copyMakeBorder(image, 50, 50, 50, 50, cv2.BORDER_REFLECT_101)
border_replicate = cv2.copyMakeBorder(image, 50, 50, 50, 50, cv2.BORDER_REPLICATE)



cv2.imshow("Border Reflect", border_reflect)
cv2.imshow("Border Reflect 101", border_reflect_101)
cv2.imshow("Border Replicate", border_replicate)

cv2.waitKey(0)
cv2.destroyAllWindows()


rgb_for_metplot(border_reflect, cv2.COLOR_BGR2RGB, "Border Reflect")
rgb_for_metplot(border_reflect_101, cv2.COLOR_BGR2RGB, "Border Reflect 101")
rgb_for_metplot(border_replicate, cv2.COLOR_BGR2RGB, "Border Replicate")

1.10.2 Examples 2

import cv2

image = cv2.imread(tomatoes)
bordered_image = cv2.copyMakeBorder(image, 10, 10, 10, 10, cv2.BORDER_CONSTANT, value=(0, 0, 255))

cv2.imshow("Red Border Image", bordered_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

rgb_for_metplot(bordered_image, cv2.COLOR_BGR2RGB, "Red Border Image")

2 Image Segmentation and Thresholding

2.1 Simple Thresholding

2.1.1 Step 1: Import libraries and Image Preparation

import cv2
import numpy as np
import matplotlib.pyplot as plt

image = cv2.imread(tomatoes)
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

2.1.2 Step 2: Helper Function

def show_image(img, title):
    plt.imshow(img, cmap='gray')
    plt.title(title)
    plt.axis('off')
    plt.show()

2.1.3 Step 3: Display the Original Image

show_image(gray_image, 'Original Grayscale Image')

2.1.4 Step 4: Binary Threshold

_, thresh_binary = cv2.threshold(gray_image, 120, 255, cv2.THRESH_BINARY)
show_image(thresh_binary, 'Binary Threshold ')

2.1.5 Step 5: Binary Threshold Inverted

_, thresh_binary_inv = cv2.threshold(
    gray_image, 120, 255, cv2.THRESH_BINARY_INV)
show_image(thresh_binary_inv, 'Binary Threshold Inverted ')

2.1.6 Step 6: Truncated Threshold

_, thresh_trunc = cv2.threshold(gray_image, 120, 255, cv2.THRESH_TRUNC)
show_image(thresh_trunc, 'Truncated Threshold')

2.1.7 Step 7: To Zero Threshold

_, thresh_tozero = cv2.threshold(gray_image, 120, 255, cv2.THRESH_TOZERO)
show_image(thresh_tozero, 'Set to 0 ')

2.1.8 Step 8: To Zero Inverted Threshold

_, thresh_tozero_inv = cv2.threshold(
    gray_image, 120, 255, cv2.THRESH_TOZERO_INV)
show_image(thresh_tozero_inv, 'Set to 0 Inverted')

2.2 Adaptive Thresholding

2.2.1 Step 1: Import libraries and Image Preparation

import cv2
import matplotlib.pyplot as plt

image = cv2.imread(morti)
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

2.2.2 Step 2: Helper Function

def show_image(img, title):
    plt.imshow(img, cmap='gray')
    plt.title(title)
    plt.axis('off')
    plt.show()

2.2.3 Step 3: Display Original Image

show_image(gray_image, "Original Grayscale Image")

2.2.4 Step 4: Adaptive Mean Thresholding

thresh_mean = cv2.adaptiveThreshold(
    gray_image, 255,
    cv2.ADAPTIVE_THRESH_MEAN_C,
    cv2.THRESH_BINARY,
    199, 5
)
show_image(thresh_mean, "Adaptive Mean Thresholding")

2.2.5 Step 5: Adaptive Gaussian Threosholding

thresh_gauss = cv2.adaptiveThreshold(
    gray_image, 255,
    cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
    cv2.THRESH_BINARY,
    199, 5
)
show_image(thresh_gauss, "Adaptive Gaussian Thresholding")

3 Morphological Operations & Filtering

3.1 Erosion and Dilation of images

3.1.1 Step 2: Load Input Image and Define the Structuring Elements(Kernel)

img = cv2.imread(tomatoes, 0)
plt.imshow(img, cmap='gray')
plt.title("Original Image")
plt.axis('off')
plt.show()
kernel = np.ones((5, 5), np.uint8)

3.1.2 Step 3: Apply Erosion

img_erosion = cv2.erode(img, kernel, iterations=1)

plt.imshow(img_erosion, cmap='gray')
plt.title("After Erosion")
plt.axis('off')
plt.show()

3.1.3 Step 4: Apply Dilation

img_dilation = cv2.dilate(img, kernel, iterations=1)

plt.imshow(img_dilation, cmap='gray')
plt.title("After Dilation")
plt.axis('off')
plt.show()

3.2 Bilateral Filtering

3.2.1 Bilateral Filter: an Additional Edge Term

import cv2

# Read the image.
img = cv2.imread(tomatoes)

# Apply bilateral filter with d = 15, 
# sigmaColor = sigmaSpace = 75.
bilateral = cv2.bilateralFilter(img, 15, 75, 75)

# Save the output.
# cv2.imwrite('taj_bilateral.jpg', bilateral)

rgb_for_metplot(bilateral, cv2.COLOR_BGR2RGB, "Bilateral Filtered Image")

3.3 Denoising of colored images

3.3.1 Example: Denoising a Noisy Image

# Importing required libraries
import numpy as np
import cv2
from matplotlib import pyplot as plt

# Reading the noisy image from file
img = cv2.imread(tomatoes)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

# Applying denoising filter
dst = cv2.fastNlMeansDenoisingColored(img, None, 10, 10, 7, 15)

# Displaying original and denoised images
plt.subplot(121), plt.imshow(img), plt.title('Original Image')
plt.subplot(122), plt.imshow(dst), plt.title('Denoised Image')
plt.show()

3.4 Filter Color with OpenCV

3.4.1 Code Example: Real-time Blue Color Detection

import cv2
import numpy as np

cap = cv2.VideoCapture(0)  # Start webcam

while True:
    _, frame = cap.read()
    # Convert BGR to HSV
    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
    
    # Define range for blue color in HSV
    lower_blue = np.array([60, 35, 140])
    upper_blue = np.array([180, 255, 255])

    # Create mask
    mask = cv2.inRange(hsv, lower_blue, upper_blue)
    
    # Filter the blue region
    result = cv2.bitwise_and(frame, frame, mask=mask)

    # Show frames
    cv2.imshow('Original Frame', frame)
    cv2.imshow('Blue Mask', mask)
    cv2.imshow('Blue Filtered Result', result)

    # Press 'q' to quit
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break  # Exit the loop when 'q' is pressed

cap.release()
cv2.destroyAllWindows()
print("Exiting...")  # Confirm exit

Exiting...

4 Advanced Image Manipulation & Background Subtraction

4.1 Image Inpainting using OpenCV

4.1.1 Creating the mask manually in OpenCV

import cv2
import numpy as np

# reading the damaged image
damaged_img = cv2.imread(filename='content/cat.png')

# get the shape of the image
height, width = damaged_img.shape[0], damaged_img.shape[1]

# Converting all pixels greater than zero to black while black becomes white
for i in range(height):
    for j in range(width):
        if damaged_img[i, j].sum() > 0:
            damaged_img[i, j] = 0
        else:
            damaged_img[i, j] = [255, 255, 255]

# saving the mask 
mask = damaged_img
cv2.imwrite('content/cat_damaged.png', mask)

# displaying mask
cv2.imshow("damaged image mask", mask)
cv2.waitKey(0)
cv2.destroyAllWindows()

import numpy as np
import cv2

# Open the image.
img = cv2.imread('content/cat_damaged.png')

# Load the mask.
mask = cv2.imread('content/mask.png', 0)

# Inpaint.
dst = cv2.inpaint(img, mask, 3, cv2.INPAINT_NS)

# Write the output.
cv2.imwrite('content/cat_inpainted.png', dst)

True

4.2 Image Registration

4.2.1 Code Section

import cv2
import numpy as np

# Open the image files.
img1_color = cv2.imread("content/im2-copy.webp")  # Image to be aligned.
img2_color = cv2.imread("content/im1-copy.webp")    # Reference image.

# Convert to grayscale.
img1 = cv2.cvtColor(img1_color, cv2.COLOR_BGR2GRAY)
img2 = cv2.cvtColor(img2_color, cv2.COLOR_BGR2GRAY)
height, width = img2.shape

# Create ORB detector with 5000 features.
orb_detector = cv2.ORB_create(5000)

# Find keypoints and descriptors.
# The first arg is the image, second arg is the mask
#  (which is not required in this case).
kp1, d1 = orb_detector.detectAndCompute(img1, None)
kp2, d2 = orb_detector.detectAndCompute(img2, None)

# Match features between the two images.
# We create a Brute Force matcher with 
# Hamming distance as measurement mode.
matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck = True)

# Match the two sets of descriptors.
matches = matcher.match(d1, d2)

# Sort matches on the basis of their Hamming distance.
# 'matches' ko list mein convert kar ke sort karein
matches = sorted(matches, key = lambda x: x.distance)

# Take the top 90 % matches forward.
matches = matches[:int(len(matches)*0.9)]
no_of_matches = len(matches)

# Define empty matrices of shape no_of_matches * 2.
p1 = np.zeros((no_of_matches, 2))
p2 = np.zeros((no_of_matches, 2))

for i in range(len(matches)):
  p1[i, :] = kp1[matches[i].queryIdx].pt
  p2[i, :] = kp2[matches[i].trainIdx].pt

# Find the homography matrix.
homography, mask = cv2.findHomography(p1, p2, cv2.RANSAC)

# Use this matrix to transform the
# colored image wrt the reference image.
transformed_img = cv2.warpPerspective(img1_color,
                    homography, (width, height))

# Save the output.
cv2.imwrite('content/output.jpg', transformed_img)

plt.imshow(cv2.cvtColor(transformed_img, cv2.COLOR_BGR2RGB))
plt.title("Aligned Image")
plt.axis('off')
plt.show()

4.3 Background subtraction

4.3.1 Example

import numpy as np
import cv2

# Load video file
cap = cv2.VideoCapture('content/people_walk.mp4')

# Create background subtractor (MOG2 handles shadows well)
fgbg = cv2.createBackgroundSubtractorMOG2()

while True:
    ret, frame = cap.read()
    if not ret:
        break  # Stop if video ends

    # Apply background subtraction
    fgmask = fgbg.apply(frame)

    # Show original and foreground mask side by side
    cv2.imshow('Original Frame', frame)
    cv2.imshow('Foreground Mask', fgmask)

    # Press 'Esc' to exit
    if cv2.waitKey(30) & 0xFF == 27:
        break

# Release resources
cap.release()
cv2.destroyAllWindows()

4.4 Background Subtraction in an Image using Concept of Running Average

import cv2
import numpy as np

# Capture video from webcam
cap = cv2.VideoCapture(0)

# Read the first frame and convert to float
_, img = cap.read()
averageValue1 = np.float32(img)

while True:
    # Capture next frame
    _, img = cap.read()
    
    # Update background model
    cv2.accumulateWeighted(img, averageValue1, 0.02)
    
    # Convert back to 8-bit for display
    resultingFrames1 = cv2.convertScaleAbs(averageValue1)

    # Show both original and background model
    cv2.imshow('Original Frame', img)
    cv2.imshow('Background (Running Average)', resultingFrames1)
    
    # Exit on Esc key
    if cv2.waitKey(30) & 0xFF == 27:
        break

# Cleanup
cap.release()
cv2.destroyAllWindows()

4.5 Foreground Extraction in an Image using Grabcut Algorithm

4.5.1 Python Implementation: Foreground Segmentation and Extraction

# Python program to illustrate foreground extraction using GrabCut algorithm

# organize imports
import numpy as np
import cv2
from matplotlib import pyplot as plt
 
# path to input image specified and 
# image is loaded with imread command
image = cv2.imread("content/another.png")
 

mask = np.zeros(image.shape[:2], np.uint8)
 

backgroundModel = np.zeros((1, 65), np.float64)
foregroundModel = np.zeros((1, 65), np.float64)
 

rectangle = (20, 100, 150, 150)
 

cv2.grabCut(image, mask, rectangle,  
            backgroundModel, foregroundModel,
            3, cv2.GC_INIT_WITH_RECT)
 

mask2 = np.where((mask == 2)|(mask == 0), 0, 1).astype('uint8')
 

image_segmented = image * mask2[:, :, np.newaxis]
 
# output segmented image with colorbar
plt.subplot(1, 2, 1)
plt.title('Original Image')
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.axis('off')

# Display the segmented image
plt.subplot(1, 2, 2)
plt.title('Segmented Image')
plt.imshow(cv2.cvtColor(image_segmented, cv2.COLOR_BGR2RGB))
plt.axis('off')

plt.show()

5 Feature Detection and Description

5.1 Line detection using Houghline method

5.1.1 Basics of Houghline Method

# Python program to illustrate HoughLine
# method for line detection
import cv2
import numpy as np

# Reading the required image in
# which operations are to be done.
# Make sure that the image is in the same
# directory in which this python program is
img = cv2.imread("content/onw-image.png")

# Convert the img to grayscale
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Apply edge detection method on the image
edges = cv2.Canny(gray, 50, 150, apertureSize=3)

# This returns an array of r and theta values
lines = cv2.HoughLines(edges, 1, np.pi/180, 200)

# The below for loop runs till r and theta values
# are in the range of the 2d array
for r_theta in lines:
    arr = np.array(r_theta[0], dtype=np.float64)
    r, theta = arr
    # Stores the value of cos(theta) in a
    a = np.cos(theta)

    # Stores the value of sin(theta) in b
    b = np.sin(theta)

    # x0 stores the value rcos(theta)
    x0 = a*r

    # y0 stores the value rsin(theta)
    y0 = b*r

    # x1 stores the rounded off value of (rcos(theta)-1000sin(theta))
    x1 = int(x0 + 1000*(-b))

    # y1 stores the rounded off value of (rsin(theta)+1000cos(theta))
    y1 = int(y0 + 1000*(a))

    # x2 stores the rounded off value of (rcos(theta)+1000sin(theta))
    x2 = int(x0 - 1000*(-b))

    # y2 stores the rounded off value of (rsin(theta)-1000cos(theta))
    y2 = int(y0 - 1000*(a))

    # cv2.line draws a line in img from the point(x1,y1) to (x2,y2).
    # (0,0,255) denotes the colour of the line to be
    # drawn. In this case, it is red.
    cv2.line(img, (x1, y1), (x2, y2), (0, 0, 255), 2)

# All the changes made in the input image are finally
# written on a new image houghlines.jpg
cv2.imwrite('linesDetected.jpg', img)

plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.title("Hough Lines Detected")
plt.axis('off')
plt.show()

print(img)

[[[  0   0 255]
  [  0   0 255]
  [  0   0 255]
  ...
  [ 82  78  78]
  [ 86  83  82]
  [ 83  79  78]]

 [[  0   0 255]
  [  0   0 255]
  [  0   0 255]
  ...
  [100  98  97]
  [101  99  98]
  [ 96  94  93]]

 [[  0   0 255]
  [  0   0 255]
  [  0   0 255]
  ...
  [123 124 122]
  [118 120 119]
  [119 121 119]]

 ...

 [[  0   0 255]
  [  0   0 255]
  [  0   0 255]
  ...
  [180 184 179]
  [180 184 179]
  [180 184 179]]

 [[  0   0 255]
  [  0   0 255]
  [  0   0 255]
  ...
  [180 184 179]
  [180 184 179]
  [180 184 179]]

 [[  0   0 255]
  [  0   0 255]
  [  0   0 255]
  ...
  [180 184 179]
  [180 184 179]
  [180 184 179]]]

5.1.2 Alternate simpler method for directly extracting points:

import cv2
import numpy as np

# Read image
image = cv2.imread('content/onw-image.png')

# Convert image to grayscale
gray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)

# Use canny edge detection
edges = cv2.Canny(gray,50,150,apertureSize=3)

# Apply HoughLinesP method to 
# to directly obtain line end points
lines_list =[]
lines = cv2.HoughLinesP(
            edges, # Input edge image
            1, # Distance resolution in pixels
            np.pi/180, # Angle resolution in radians
            threshold=100, # Min number of votes for valid line
            minLineLength=5, # Min allowed length of line
            maxLineGap=10 # Max allowed gap between line for joining them
            )

# Iterate over points
for points in lines:
      # Extracted points nested in the list
    x1,y1,x2,y2=points[0]
    # Draw the lines joing the points
    # On the original image
    cv2.line(image,(x1,y1),(x2,y2),(0,255,0),2)
    # Maintain a simples lookup list for points
    lines_list.append([(x1,y1),(x2,y2)])
    
# Save the result image
cv2.imwrite('detectedLines.png',image)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title("Hough Lines Detected with HoughLinesP")
plt.axis('off')
plt.show()

5.2 Circle Detection

5.2.1 Example: Detecting Circles in an Eye Image

import cv2
import numpy as np

# Read image
img = cv2.imread(camer)
output = img.copy()
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Reduce noise
gray = cv2.medianBlur(gray, 5)

# Detect circles
circles = cv2.HoughCircles(
    gray,
    cv2.HOUGH_GRADIENT,
    dp=1,
    minDist=100,      
    param1=100,         
    param2=40,       
    minRadius=30,       
    maxRadius=60
)

# Draw only the first detected circle
if circles is not None:
    circles = np.uint16(np.around(circles))
    x, y, r = circles[0][0]
    cv2.circle(output, (x, y), r, (0, 255, 0), 2)  # Circle outline
    cv2.circle(output, (x, y), 2, (0, 0, 255), 3)  # Center point

# Show result
cv2.imshow('Detected Circle', output)
cv2.waitKey(0)
cv2.destroyAllWindows()

plt.imshow(cv2.cvtColor(output, cv2.COLOR_BGR2RGB))
plt.title("Hough Circle Detected")
plt.axis('off')
plt.show()

5.3 Detect corner of an image

5.3.1 Step 1: Import Libraries

import numpy as np
import cv2
from matplotlib import pyplot as plt

5.3.2 Step 2: Load and Preprocess the Image

img = cv2.imread(tomatoes)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

print(img)

[[[174 195 192]
  [174 194 191]
  [175 195 191]
  ...
  [139 179 158]
  [139 178 161]
  [142 166 153]]

 [[135 213 203]
  [136 211 201]
  [139 212 203]
  ...
  [  8 105  56]
  [ 13  65  35]
  [ 19  75  32]]

 [[137 215 207]
  [137 212 202]
  [138 211 203]
  ...
  [ 17  38  18]
  [ 26  85  36]
  [ 30 125  23]]

 ...

 [[ 31 121  46]
  [ 26 128  56]
  [ 26 133  65]
  ...
  [ 74 171 167]
  [ 77 173 161]
  [ 82 178 159]]

 [[ 32 121  44]
  [ 36 130  61]
  [ 36 133  68]
  ...
  [ 59 158 161]
  [ 59 158 157]
  [ 60 162 153]]

 [[ 33 121  43]
  [ 44 130  63]
  [ 46 132  72]
  ...
  [ 61 150 159]
  [ 52 146 151]
  [ 31 142 133]]]

5.3.3 Step 3: Detect Corners

corners = cv2.goodFeaturesToTrack(
    gray,
    maxCorners=27,
    qualityLevel=0.01,
    minDistance=10,
    blockSize=3,
    useHarrisDetector=False,
    k=0.04
)

5.3.4 Step 4: Draw and Display Results

corners = np.intp(corners)  # Convert to integer coords
for corner in corners:
    x, y = corner.ravel()
    cv2.circle(img, (x, y), radius=3, color=(0, 255, 0), thickness=-1)

plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.title('Corners Detected')
plt.axis('off')
plt.show()

5.4 Corner Detection with Shi-Tomasi method

5.4.1 Implementing Shi-Tomasi Corner Detection

import cv2
import numpy as np
import matplotlib.pyplot as plt

img = cv2.imread(tomatoes)

gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

corners = cv2.goodFeaturesToTrack(gray_img, 100, 0.01, 10)
corners = np.int32(corners)

for i in corners:
    x, y = i.ravel()
    cv2.circle(img, (x, y), 3, (0, 0, 255), -1)  

img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

plt.imshow(img_rgb)
plt.title('Shi-Tomasi Corner Detection')
plt.axis('off')  
plt.show()

5.5 Corner detection with Harris Corner Detection

5.5.1 Implementing Harris Corner Detection

import cv2
import numpy as np
import matplotlib.pyplot as plt

imagepath = camer
image = cv2.imread(imagepath)

operatedImage = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
operatedImage = np.float32(operatedImage)


dest = cv2.cornerHarris(operatedImage, 17, 21, 0.01)
dest = cv2.dilate(dest, None)

image[dest > 0.01 * dest.max()] = [0, 0, 255]
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

plt.imshow(image_rgb)
plt.title('Harris Corner Detection')
plt.axis('off')  
plt.show()

5.6 Find Circles and Ellipses in an Image

import cv2
import numpy as np

# Load image
image = cv2.imread("content/cpy.png", 0)

# Set our filtering parameters
# Initialize parameter setting using cv2.SimpleBlobDetector
params = cv2.SimpleBlobDetector_Params()

# Set Area filtering parameters
params.filterByArea = True
params.minArea = 100

# Set Circularity filtering parameters
params.filterByCircularity = True 
params.minCircularity = 0.9

# Set Convexity filtering parameters
params.filterByConvexity = True
params.minConvexity = 0.2
    
# Set inertia filtering parameters
params.filterByInertia = True
params.minInertiaRatio = 0.01

# Create a detector with the parameters
detector = cv2.SimpleBlobDetector_create(params)
    
# Detect blobs
keypoints = detector.detect(image)

# Draw blobs on our image as red circles
blank = np.zeros((1, 1)) 
blobs = cv2.drawKeypoints(image, keypoints, blank, (0, 0, 255),
                          cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)

number_of_blobs = len(keypoints)
text = "Number of Circular Blobs: " + str(len(keypoints))
cv2.putText(blobs, text, (20, 550),
            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 100, 255), 2)

# Show blobs
cv2.imshow("Filtering Circular Blobs Only", blobs)
cv2.waitKey(0)
cv2.destroyAllWindows()


plt.imshow(blobs, cmap='gray')

<matplotlib.image.AxesImage at 0x1b38564c9e0>

5.7 Document field detection

import numpy as np
import cv2
import matplotlib.pyplot as plt

# 1. Thresholds ko scores se thora sa kam rakha hai taake detection pakki ho
field_threshold = { 
    "prev_policy_no" : 0.40, # Score 0.43 tha, isliye 0.40 rakha
    "address"        : 0.70  # Score 0.80 tha, isliye 0.75 rakha
}

def getBoxed(img, img_gray, template, field_name):
    if template is None:
        print(f"Warning: {field_name} ka template nahi mila!")
        return img

    w, h = template.shape[::-1] 
    res = cv2.matchTemplate(img_gray, template, cv2.TM_CCOEFF_NORMED)
    
    # Best score nikalne ke liye
    _, max_val, _, _ = cv2.minMaxLoc(res)
    # print(f"Field: {field_name} | Best Match Score: {max_val:.4f} (Threshold: {field_threshold[field_name]})")
        
    # Sirf un points ko pakrein jo threshold se upar hain
    loc = np.where(res >= field_threshold[field_name])
    
    rects = []
    for pt in zip(*loc[::-1]):
        # [x, y, w, h]
        rects.append([int(pt[0]), int(pt[1]), int(w), int(h)])
        # groupRectangles ko list do baar chahiye hoti hai agar matches kam hon
        rects.append([int(pt[0]), int(pt[1]), int(w), int(h)])
    
    if len(rects) > 0:
        # groupThreshold=1 matlab overlapping boxes ko merge karo
        # eps=0.5 thora zyada rakha hai taake door door wale boxes merge na hon
        rects, weights = cv2.groupRectangles(rects, groupThreshold=1, eps=0.5)
        
        for (x, y, w, h) in rects:
            # Yellow Box
            cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 255), 2)
            
            # Label background (patti) taake text saaf nazar aaye
            label = f"{field_name}: {max_val:.2f}"
            cv2.rectangle(img, (x, y - 25), (x + w, y), (0, 255, 255), -1)
            cv2.putText(img, label, (x + 5, y - 7), 
                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)
    else:
        print(f"--- No match found for {field_name} ---")

    return img

# --- MAIN EXECUTION ---
img = cv2.imread('content/doc.png')
if img is None:
    print("Error: content/doc.png nahi mili!")
else:
    img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    # Grayscale mein hi load karein templates ko
    template_add = cv2.imread('content/doc_address.png', 0)
    template_prev = cv2.imread('content/doc_prev_policy.png', 0)

    output_img = img.copy()
    output_img = getBoxed(output_img, img_gray, template_add, 'address')
    output_img = getBoxed(output_img, img_gray, template_prev, 'prev_policy_no')

    plt.figure(figsize=(15, 10))
    plt.imshow(cv2.cvtColor(output_img, cv2.COLOR_BGR2RGB))
    plt.title("Detected Fields Results")
    plt.axis('off')
    plt.show()

print(img)

[[[248 248 248]
  [248 248 248]
  [249 249 249]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[248 248 248]
  [248 248 248]
  [249 249 249]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[248 248 248]
  [248 248 248]
  [249 249 249]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 ...

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]

 [[255 255 255]
  [255 255 255]
  [255 255 255]
  ...
  [255 255 255]
  [255 255 255]
  [255 255 255]]]

5.8 Smile detection

5.8.1 Step 1: Importing OpenCV library

import cv2

5.8.2 Step 2: Loading Pre-trained Classifiers

face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades +'haarcascade_frontalface_default.xml')
eye_cascade = cv2.CascadeClassifier(cv2.data.haarcascades +'haarcascade_eye.xml')
smile_cascade = cv2.CascadeClassifier(cv2.data.haarcascades +'haarcascade_smile.xml')

5.8.3 Step 3: Starting Webcam Capture

cap = cv2.VideoCapture(0)

5.8.4 Step 4: Processing Each Frame

while True:
    ret, frame = cap.read()
    
    if not ret:
        print("Failed to grab frame.")
        break

    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    faces = face_cascade.detectMultiScale(gray, scaleFactor=1.3, minNeighbors=5)

    for (x, y, w, h) in faces:
        cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0), 2)
        roi_gray = gray[y:y + h, x:x + w]

        smiles = smile_cascade.detectMultiScale(roi_gray, scaleFactor=1.8, minNeighbors=20, minSize=(25, 25))

        for (sx, sy, sw, sh) in smiles:
            cv2.rectangle(frame, (x + sx, y + sy), (x + sx + sw, y + sy + sh), (0, 255, 0), 2)

    cv2.imshow('Smile Detection', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
    
cap.release()
cv2.destroyAllWindows()

5.9 Feature extraction and image classification using OpenCV

5.9.1 Step 1: Install OpenCV

# !pip install opencv-python

Requirement already satisfied: opencv-python in c:\users\hp\onedrive\desktop\open cv\whyi\lib\site-packages (4.13.0.92)
Requirement already satisfied: numpy>=2 in c:\users\hp\onedrive\desktop\open cv\whyi\lib\site-packages (from opencv-python) (2.4.2)

[notice] A new release of pip is available: 24.0 -> 26.0.1
[notice] To update, run: python.exe -m pip install --upgrade pip

5.9.2 Step 2: Import Libraries

import cv2
import numpy as np
import matplotlib.pyplot as plt

5.9.3 Step 3: Load an Image

image = cv2.imread(morti)
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

5.9.4 Step 4: Use Edge Detection

edges = cv2.Canny(gray_image, 100, 200)
plt.imshow(edges, cmap='gray')
plt.title('Edge Image')
plt.show()

5.9.5 Step 5: Use Feature Detectors

sift = cv2.SIFT_create()
keypoints, descriptors = sift.detectAndCompute(gray_image, None)
image_with_sift = cv2.drawKeypoints(image, keypoints, None)
plt.imshow(cv2.cvtColor(image_with_sift, cv2.COLOR_BGR2RGB))
plt.title('SIFT Features')
plt.show()

orb = cv2.ORB_create()
keypoints, descriptors = orb.detectAndCompute(gray_image, None)
image_with_orb = cv2.drawKeypoints(image, keypoints, None, flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
plt.imshow(cv2.cvtColor(image_with_orb, cv2.COLOR_BGR2RGB))
plt.title('ORB Features')
plt.show()

5.9.6 Step 1: Install the necessary libraries

# !pip install PyWaveletspip opencv-python

ERROR: Could not find a version that satisfies the requirement PyWaveletspip (from versions: none)
ERROR: No matching distribution found for PyWaveletspip

[notice] A new release of pip is available: 24.0 -> 26.0.1
[notice] To update, run: python.exe -m pip install --upgrade pip

5.9.7 Step 2: Importing Necessary Libraries

import numpy as np
import cv2
import matplotlib
import matplotlib.pyplot as plt
%matplotlib inline

5.9.8 Step 2: Loading and Displaying the Image

img = cv2.imread("content/face.jpg")
rgb_for_metplot(img, cv2.COLOR_BGR2RGB, "Original Image")

5.9.9 Step 4: Converting Image to Grayscale

#Converting the image to gray
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
gray.shape
rgb_for_metplot(gray, cv2.COLOR_GRAY2RGB, "Grayscale Image")

plt.imshow(gray, cmap='gray')

<matplotlib.image.AxesImage at 0x1b3ffe5f350>

5.9.10 Step 5: Loading Haar Cascades for Face and Eye Detection

import cv2

face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
eye_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_eye.xml')

faces = face_cascade.detectMultiScale(gray, 1.3, 5)

faces

array([[43, 56, 97, 97]], dtype=int32)

print(f"Is classifier empty? {face_cascade.empty()}") 

if not face_cascade.empty():
    faces = face_cascade.detectMultiScale(gray, 1.3, 5)
    print(f"Faces found: {len(faces)}")
else:
    print("XML file load nahi hui, path sahi karein!")

Is classifier empty? False
Faces found: 1

(x,y,w,h) = faces[0]
x,y,w,h

(np.int32(43), np.int32(56), np.int32(97), np.int32(97))

5.9.11 Step 6: Detecting Faces and Drawing Rectangles Around Them

face_img = cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
plt.imshow(face_img)

<matplotlib.image.AxesImage at 0x1b380245e80>

5.9.12 Step 7: Detecting Faces , eyes and Drawing Rectangles Around Them

cv2.destroyAllWindows()
for (x,y,w,h) in faces:
    face_img = cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
    roi_gray = gray[y:y+h, x:x+w]
    roi_color = face_img[y:y+h, x:x+w]
    eyes = eye_cascade.detectMultiScale(roi_gray)
    for (ex,ey,ew,eh) in eyes:
        cv2.rectangle(roi_color,(ex,ey),(ex+ew,ey+eh),(0,255,0),2)
        

plt.figure()
plt.imshow(face_img, cmap='gray')
plt.show()

#Plotting the cropped Image
%matplotlib inline
plt.imshow(roi_color, cmap='gray')
plt.show()

cropped_img = np.array(roi_color)
cropped_img.shape

(97, 97, 3)

5.9.13 Step 8: Performing a 2D wavelet transform on an image

import numpy as np
import pywt
import cv2    

def w2d(img, mode='haar', level=1):
    imArray = img
    #Datatype conversions
    #convert to grayscale
    imArray = cv2.cvtColor( imArray,cv2.COLOR_RGB2GRAY )
    #convert to float
    imArray =  np.float32(imArray)   
    imArray /= 255;
    # compute coefficients 
    coeffs=pywt.wavedec2(imArray, mode, level=level)

    #Process Coefficients
    coeffs_H=list(coeffs)  
    coeffs_H[0] *= 0;  

    # reconstruction
    imArray_H=pywt.waverec2(coeffs_H, mode);
    imArray_H *= 255;
    imArray_H =  np.uint8(imArray_H)

    return imArray_H

5.9.14 Step 9: Function to Get Cropped Image with Two Eyes

im_har = w2d(cropped_img,'db1',5)
plt.imshow(im_har, cmap='gray')

<matplotlib.image.AxesImage at 0x1b39848ab70>

5.9.15 Step 10: Preprocessing: Load image, detect face. If eyes >=2, then save and crop the face region

def get_cropped_image_if_2_eyes(image_path):
    img = cv2.imread(image_path)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    faces = face_cascade.detectMultiScale(gray, 1.3, 5)
    for (x,y,w,h) in faces:
        roi_gray = gray[y:y+h, x:x+w]
        roi_color = img[y:y+h, x:x+w]
        eyes = eye_cascade.detectMultiScale(roi_gray)
        if len(eyes) >= 2:
            return roi_color
          
original_image = cv2.imread('content/face.jpg')
plt.imshow(original_image)

<matplotlib.image.AxesImage at 0x1b3802b0200>

cropped_image = get_cropped_image_if_2_eyes('content/face.jpg')
plt.imshow(cropped_image)

<matplotlib.image.AxesImage at 0x1b385a8eb10>

5.9.16 Step 9: Preparing and Organizing the Dataset

path_to_data = "./images/"
path_to_cr_data = "./images/cropped/"

import os
img_dirs = []
for entry in os.scandir(path_to_data):
    if entry.is_dir():
        img_dirs.append(entry.path)
img_dirs

['./images/bhuvneshwar_kumar',
 './images/dinesh_karthik',
 './images/hardik_pandya',
 './images/jasprit_bumrah',
 './images/mohammed_shami',
 './images/ms_dhoni']

import shutil
if os.path.exists(path_to_cr_data):
     shutil.rmtree(path_to_cr_data)
os.mkdir(path_to_cr_data)

cropped_image_dirs = []
celebrity_file_names_dict = {}

for img_dir in img_dirs:
    count = 1
    celebrity_name = img_dir.split('/')[-1]
    print(celebrity_name)
    
    celebrity_file_names_dict[celebrity_name] = []
    
    for entry in os.scandir(img_dir):
        roi_color = get_cropped_image_if_2_eyes(entry.path)
        if roi_color is not None:
            cropped_folder = path_to_cr_data + celebrity_name
            if not os.path.exists(cropped_folder):
                os.makedirs(cropped_folder)
                cropped_image_dirs.append(cropped_folder)
                print("Generating cropped images in folder: ",cropped_folder)
                
            cropped_file_name = celebrity_name + str(count) + ".png"
            cropped_file_path = cropped_folder + "/" + cropped_file_name 
            
            cv2.imwrite(cropped_file_path, roi_color)
            celebrity_file_names_dict[celebrity_name].append(cropped_file_path)
            count += 1

bhuvneshwar_kumar
Generating cropped images in folder:  ./images/cropped/bhuvneshwar_kumar
dinesh_karthik
Generating cropped images in folder:  ./images/cropped/dinesh_karthik
hardik_pandya
Generating cropped images in folder:  ./images/cropped/hardik_pandya
jasprit_bumrah
Generating cropped images in folder:  ./images/cropped/jasprit_bumrah
mohammed_shami
Generating cropped images in folder:  ./images/cropped/mohammed_shami
ms_dhoni
Generating cropped images in folder:  ./images/cropped/ms_dhoni

5.9.17 Step 10: Creating a Dictionary for Training Files

celebrity_file_names_dict = {}
for img_dir in cropped_image_dirs:
    celebrity_name = img_dir.split('/')[-1]
    file_list = []
    for entry in os.scandir(img_dir):
        file_list.append(entry.path)
    celebrity_file_names_dict[celebrity_name] = file_list
celebrity_file_names_dict

{'bhuvneshwar_kumar': ['./images/cropped/bhuvneshwar_kumar\\bhuvneshwar_kumar1.png',
  './images/cropped/bhuvneshwar_kumar\\bhuvneshwar_kumar10.png',
  './images/cropped/bhuvneshwar_kumar\\bhuvneshwar_kumar11.png',
  './images/cropped/bhuvneshwar_kumar\\bhuvneshwar_kumar12.png',
  './images/cropped/bhuvneshwar_kumar\\bhuvneshwar_kumar2.png',
  './images/cropped/bhuvneshwar_kumar\\bhuvneshwar_kumar3.png',
  './images/cropped/bhuvneshwar_kumar\\bhuvneshwar_kumar4.png',
  './images/cropped/bhuvneshwar_kumar\\bhuvneshwar_kumar5.png',
  './images/cropped/bhuvneshwar_kumar\\bhuvneshwar_kumar6.png',
  './images/cropped/bhuvneshwar_kumar\\bhuvneshwar_kumar7.png',
  './images/cropped/bhuvneshwar_kumar\\bhuvneshwar_kumar8.png',
  './images/cropped/bhuvneshwar_kumar\\bhuvneshwar_kumar9.png'],
 'dinesh_karthik': ['./images/cropped/dinesh_karthik\\dinesh_karthik1.png',
  './images/cropped/dinesh_karthik\\dinesh_karthik2.png',
  './images/cropped/dinesh_karthik\\dinesh_karthik3.png',
  './images/cropped/dinesh_karthik\\dinesh_karthik4.png',
  './images/cropped/dinesh_karthik\\dinesh_karthik5.png',
  './images/cropped/dinesh_karthik\\dinesh_karthik6.png',
  './images/cropped/dinesh_karthik\\dinesh_karthik7.png',
  './images/cropped/dinesh_karthik\\dinesh_karthik8.png',
  './images/cropped/dinesh_karthik\\dinesh_karthik9.png'],
 'hardik_pandya': ['./images/cropped/hardik_pandya\\hardik_pandya1.png',
  './images/cropped/hardik_pandya\\hardik_pandya10.png',
  './images/cropped/hardik_pandya\\hardik_pandya2.png',
  './images/cropped/hardik_pandya\\hardik_pandya3.png',
  './images/cropped/hardik_pandya\\hardik_pandya4.png',
  './images/cropped/hardik_pandya\\hardik_pandya5.png',
  './images/cropped/hardik_pandya\\hardik_pandya6.png',
  './images/cropped/hardik_pandya\\hardik_pandya7.png',
  './images/cropped/hardik_pandya\\hardik_pandya8.png',
  './images/cropped/hardik_pandya\\hardik_pandya9.png'],
 'jasprit_bumrah': ['./images/cropped/jasprit_bumrah\\jasprit_bumrah1.png',
  './images/cropped/jasprit_bumrah\\jasprit_bumrah2.png',
  './images/cropped/jasprit_bumrah\\jasprit_bumrah3.png',
  './images/cropped/jasprit_bumrah\\jasprit_bumrah4.png'],
 'mohammed_shami': ['./images/cropped/mohammed_shami\\mohammed_shami1.png',
  './images/cropped/mohammed_shami\\mohammed_shami2.png',
  './images/cropped/mohammed_shami\\mohammed_shami3.png',
  './images/cropped/mohammed_shami\\mohammed_shami4.png',
  './images/cropped/mohammed_shami\\mohammed_shami5.png',
  './images/cropped/mohammed_shami\\mohammed_shami6.png',
  './images/cropped/mohammed_shami\\mohammed_shami7.png',
  './images/cropped/mohammed_shami\\mohammed_shami8.png'],
 'ms_dhoni': ['./images/cropped/ms_dhoni\\ms_dhoni1.png',
  './images/cropped/ms_dhoni\\ms_dhoni10.png',
  './images/cropped/ms_dhoni\\ms_dhoni11.png',
  './images/cropped/ms_dhoni\\ms_dhoni12.png',
  './images/cropped/ms_dhoni\\ms_dhoni13.png',
  './images/cropped/ms_dhoni\\ms_dhoni14.png',
  './images/cropped/ms_dhoni\\ms_dhoni2.png',
  './images/cropped/ms_dhoni\\ms_dhoni3.png',
  './images/cropped/ms_dhoni\\ms_dhoni4.png',
  './images/cropped/ms_dhoni\\ms_dhoni5.png',
  './images/cropped/ms_dhoni\\ms_dhoni6.png',
  './images/cropped/ms_dhoni\\ms_dhoni7.png',
  './images/cropped/ms_dhoni\\ms_dhoni8.png',
  './images/cropped/ms_dhoni\\ms_dhoni9.png']}

5.9.18 Step 11: Creating a Class Dictionary

class_dict = {}
count = 0
for celebrity_name in celebrity_file_names_dict.keys():
    class_dict[celebrity_name] = count
    count = count + 1
class_dict

{'bhuvneshwar_kumar': 0,
 'dinesh_karthik': 1,
 'hardik_pandya': 2,
 'jasprit_bumrah': 3,
 'mohammed_shami': 4,
 'ms_dhoni': 5}

5.9.19 Step 12: Preparing the Feature Vectors

X, y = [], []
for celebrity_name, training_files in celebrity_file_names_dict.items():
    for training_image in training_files:
        img = cv2.imread(training_image)
        if img is None:
            continue
        
        scalled_raw_img = cv2.resize(img, (32, 32))
        
        img_har = w2d(img, 'db1', 5)
        scalled_img_har = cv2.resize(img_har, (32, 32))
        
        combined_img = np.vstack((
            scalled_raw_img.reshape(32*32*3, 1), 
            scalled_img_har.reshape(32*32, 1)
        )).flatten() 
        
        X.append(combined_img)
        y.append(class_dict[celebrity_name])


X = np.array(X).astype(float)
y = np.array(y)

5.9.20 Step 13: Training the SVM Classifier

from sklearn.svm import SVC
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.metrics import classification_report
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

pipe = Pipeline([('scaler', StandardScaler()), ('svc', SVC(kernel = 'rbf', C = 10))])
pipe.fit(X_train, y_train)
pipe.score(X_test, y_test)

0.4

print(classification_report(y_test, pipe.predict(X_test)))

              precision    recall  f1-score   support

           0       0.60      0.75      0.67         4
           1       0.00      0.00      0.00         0
           2       1.00      0.33      0.50         3
           3       0.00      0.00      0.00         3
           4       0.00      0.00      0.00         2
           5       0.33      0.67      0.44         3

    accuracy                           0.40        15
   macro avg       0.32      0.29      0.27        15
weighted avg       0.43      0.40      0.37        15

c:\Users\HP\OneDrive\Desktop\OPEN CV\whyi\Lib\site-packages\sklearn\metrics\_classification.py:1833: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, f"{metric.capitalize()} is", result.shape[0])
c:\Users\HP\OneDrive\Desktop\OPEN CV\whyi\Lib\site-packages\sklearn\metrics\_classification.py:1833: UndefinedMetricWarning: Recall is ill-defined and being set to 0.0 in labels with no true samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, f"{metric.capitalize()} is", result.shape[0])
c:\Users\HP\OneDrive\Desktop\OPEN CV\whyi\Lib\site-packages\sklearn\metrics\_classification.py:1833: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, f"{metric.capitalize()} is", result.shape[0])
c:\Users\HP\OneDrive\Desktop\OPEN CV\whyi\Lib\site-packages\sklearn\metrics\_classification.py:1833: UndefinedMetricWarning: Recall is ill-defined and being set to 0.0 in labels with no true samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, f"{metric.capitalize()} is", result.shape[0])
c:\Users\HP\OneDrive\Desktop\OPEN CV\whyi\Lib\site-packages\sklearn\metrics\_classification.py:1833: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, f"{metric.capitalize()} is", result.shape[0])
c:\Users\HP\OneDrive\Desktop\OPEN CV\whyi\Lib\site-packages\sklearn\metrics\_classification.py:1833: UndefinedMetricWarning: Recall is ill-defined and being set to 0.0 in labels with no true samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, f"{metric.capitalize()} is", result.shape[0])

6 Feature Detection & Analysis

6.1 Find Co-ordinates of Contours

6.1.1 Python Implementation

import numpy as np
import cv2

font = cv2.FONT_HERSHEY_COMPLEX

# Load image
img2 = cv2.imread('content/test.jpg', cv2.IMREAD_COLOR)
img = cv2.imread('content/test.jpg', cv2.IMREAD_GRAYSCALE)

# Binarize image
_, threshold = cv2.threshold(img, 110, 255, cv2.THRESH_BINARY)

# Find contours
contours, _ = cv2.findContours(threshold, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

for cnt in contours:
    # Approximate and draw contour
    approx = cv2.approxPolyDP(cnt, 0.009 * cv2.arcLength(cnt, True), True)
    cv2.drawContours(img2, [approx], 0, (0, 0, 255), 5)

    # Flatten points
    n = approx.ravel()
    i = 0
    for j in n:
        if i % 2 == 0:  # x, y coords
            x, y = n[i], n[i + 1]
            coord = f"{x} {y}"
            if i == 0:  # first point
                cv2.putText(img2, "Arrow tip", (x, y), font, 0.5, (255, 0, 0))
            else:
                cv2.putText(img2, coord, (x, y), font, 0.5, (0, 255, 0))
        i += 1

# Show result
cv2.imshow('Contours with Coordinates', img2)

# Exit on 'q'
if cv2.waitKey(0) & 0xFF == ord('q'):
    cv2.destroyAllWindows()

plt.imshow(cv2.cvtColor(img2, cv2.COLOR_BGR2RGB))
plt.title("Contours with Coordinates")
plt.axis('off')
plt.show()

6.2 Analyze an image using Histogram

6.2.1 Importing image data

import matplotlib.pyplot as plt
import cv2

img = plt.imread(tomatoes)  
plt.imshow(img)
plt.title("Original Image")
plt.show()

6.2.2 Creating Histogram using Numpy & Matplotlib

import cv2, matplotlib.pyplot as plt
img = cv2.imread(tomatoes)

# Grayscale + Histogram
g = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
plt.subplot(121), plt.imshow(g, cmap='gray'), plt.axis("off"), plt.title("Grayscale")
plt.subplot(122), plt.hist(g.ravel(),256,[0,256],color='k'), plt.title("Gray Histogram")
plt.show()

# RGB Histograms
for i,c in enumerate(('r','g','b')):
    plt.plot(cv2.calcHist([img],[i],None,[256],[0,256]), color=c)
plt.title("RGB Histograms"), plt.xlabel("Intensity"), plt.ylabel("Frequency")
plt.show()

C:\Users\HP\AppData\Local\Temp\ipykernel_4036\1510350441.py:7: MatplotlibDeprecationWarning: Passing the range parameter of hist() positionally is deprecated since Matplotlib 3.10; the parameter will become keyword-only in 3.12.
  plt.subplot(122), plt.hist(g.ravel(),256,[0,256],color='k'), plt.title("Gray Histogram")

6.2.3 Histogram Calculation using OpenCV

img = cv2.imread(tomatoes, 0)
histg = cv2.calcHist([img], [0], None, [256], [0, 256])

# Plot histogram
plt.plot(histg)
plt.title("Histogram using OpenCV calcHist()")
plt.xlabel("Pixel Intensity")
plt.ylabel("Frequency")
plt.show()

6.2.4 Histogram for Color Images

img = cv2.imread(tomatoes)

# colors for channels
colors = ('b', 'g', 'r')

for i, col in enumerate(colors):
    hist = cv2.calcHist([img], [i], None, [256], [0, 256])
    plt.plot(hist, color=col)
    plt.xlim([0, 256])

plt.title("RGB Color Histogram")
plt.xlabel("Pixel Intensity")
plt.ylabel("Frequency")
plt.show()

6.2.5 Using OpenCV (cvcalcHist())

import cv2
from matplotlib import pyplot as plt
img = cv2.imread(tomatoes,0)

histr = cv2.calcHist([img],[0],None,[256],[0,256])
plt.plot(histr)
plt.show()

6.2.6 Using plt.hist()

import cv2
from matplotlib import pyplot as plt
img = cv2.imread(tomatoes,0)

# alternative way to find histogram of an image
plt.hist(img.ravel(),256,[0,256])
plt.show()

C:\Users\HP\AppData\Local\Temp\ipykernel_4036\1419790081.py:6: MatplotlibDeprecationWarning: Passing the range parameter of hist() positionally is deprecated since Matplotlib 3.10; the parameter will become keyword-only in 3.12.
  plt.hist(img.ravel(),256,[0,256])

The Kernel crashed while executing code in the current cell or a previous cell. 

Please review the code in the cell(s) to identify a possible cause of the failure. 

Click <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. 

View Jupyter <a href='command:jupyter.viewOutput'>log</a> for further details.